home *** CD-ROM | disk | FTP | other *** search
/ AmigActive 26 / AACD 26.iso / AACD / Online / x3270 / unix_files / CmplxMenu.c < prev    next >
Encoding:
C/C++ Source or Header  |  2008-10-18  |  39.7 KB  |  1,376 lines
  1. /* (from) $XConsortium: SimpleMenu.c,v 1.41 92/09/10 16:25:07 converse Exp $ */
  2.  
  3. /*
  4.  * Modifications Copyright 1995, 1999 by Paul Mattes.
  5.  *  Permission to use, copy, modify, and distribute this software and its
  6.  *  documentation for any purpose and without fee is hereby granted,
  7.  *  provided that the above copyright notice appear in all copies and that
  8.  *  both that copyright notice and this permission notice appear in
  9.  *  supporting documentation.
  10.  *
  11.  * Copyright 1989 Massachusetts Institute of Technology
  12.  *
  13.  * Permission to use, copy, modify, distribute, and sell this software and its
  14.  * documentation for any purpose is hereby granted without fee, provided that
  15.  * the above copyright notice appear in all copies and that both that
  16.  * copyright notice and this permission notice appear in supporting
  17.  * documentation, and that the name of M.I.T. not be used in advertising or
  18.  * publicity pertaining to distribution of the software without specific,
  19.  * written prior permission.  M.I.T. makes no representations about the
  20.  * suitability of this software for any purpose.  It is provided "as is"
  21.  * without express or implied warranty.
  22.  *
  23.  * M.I.T. DISCLAIMS ALL WARRANTIES WITH REGARD TO THIS SOFTWARE, INCLUDING ALL
  24.  * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS, IN NO EVENT SHALL M.I.T.
  25.  * BE LIABLE FOR ANY SPECIAL, INDIRECT OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES
  26.  * WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN ACTION
  27.  * OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF OR IN 
  28.  * CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.
  29.  */
  30.  
  31. /*
  32.  * ComplexMenu.c - Source code file for ComplexMenu widget.
  33.  * (from) SimpleMenu.c - Source code file for SimpleMenu widget.
  34.  *
  35.  * Date:    April 3, 1989
  36.  *
  37.  * By:      Chris D. Peterson
  38.  *          MIT X Consortium 
  39.  *          kit@expo.lcs.mit.edu
  40.  */
  41.  
  42. #include "globals.h"
  43. #if defined(X3270_MENUS) /*[*/
  44.  
  45. #include <stdio.h>
  46. #include <X11/IntrinsicP.h>
  47. #include <X11/StringDefs.h>
  48.  
  49. #include <X11/Xaw/XawInit.h>
  50. #include "CmplxMenuP.h"
  51. #include "CmeBSB.h"
  52. #include <X11/Xaw/Cardinals.h>
  53. #include <X11/Xaw/MenuButton.h>
  54.  
  55. #include <X11/Xmu/Initer.h>
  56. #include <X11/Xmu/CharSet.h>
  57.  
  58. #define streq(a, b)        ( strcmp((a), (b)) == 0 )
  59.  
  60. #define offset(field) XtOffsetOf(ComplexMenuRec, complex_menu.field)
  61.  
  62. static XtResource resources[] = { 
  63.  
  64. /*
  65.  * Label Resources.
  66.  */
  67.  
  68.   {XtNlabel,  XtCLabel, XtRString, sizeof(String),
  69.      offset(label_string), XtRString, NULL},
  70.   {XtNlabelClass,  XtCLabelClass, XtRPointer, sizeof(WidgetClass),
  71.      offset(label_class), XtRImmediate, (XtPointer) NULL},
  72.  
  73. /*
  74.  * Layout Resources.
  75.  */
  76.  
  77.   {XtNrowHeight,  XtCRowHeight, XtRDimension, sizeof(Dimension),
  78.      offset(row_height), XtRImmediate, (XtPointer) 0},
  79.   {XtNtopMargin,  XtCVerticalMargins, XtRDimension, sizeof(Dimension),
  80.      offset(top_margin), XtRImmediate, (XtPointer) 0},
  81.   {XtNbottomMargin,  XtCVerticalMargins, XtRDimension, sizeof(Dimension),
  82.      offset(bottom_margin), XtRImmediate, (XtPointer) 0},
  83.  
  84. /*
  85.  * Misc. Resources
  86.  */
  87.  
  88.   { XtNallowShellResize, XtCAllowShellResize, XtRBoolean, sizeof(Boolean),
  89.       XtOffsetOf(ComplexMenuRec, shell.allow_shell_resize),
  90.       XtRImmediate, (XtPointer) TRUE },
  91.   {XtNcursor, XtCCursor, XtRCursor, sizeof(Cursor),
  92.       offset(cursor), XtRImmediate, (XtPointer) None},
  93.   {XtNmenuOnScreen,  XtCMenuOnScreen, XtRBoolean, sizeof(Boolean),
  94.       offset(menu_on_screen), XtRImmediate, (XtPointer) TRUE},
  95.   {XtNpopupOnEntry,  XtCPopupOnEntry, XtRWidget, sizeof(Widget),
  96.       offset(popup_entry), XtRWidget, NULL},
  97.   {XtNbackingStore, XtCBackingStore, XtRBackingStore, sizeof (int),
  98.       offset(backing_store), 
  99.       XtRImmediate, (XtPointer) (Always + WhenMapped + NotUseful)},
  100.   {XtNcMparent, XtCCMparent, XtRWidget, sizeof(Widget),
  101.       offset(parent), XtRWidget, NULL},
  102.   {XtNcMdefer, XtCCMdefer, XtRWidget, sizeof(Widget),
  103.       offset(deferred_notify), XtRWidget, NULL},
  104. };  
  105. #undef offset
  106.  
  107. static char defaultTranslations[] =
  108.     "<EnterWindow>:     highlight()             \n\
  109.      <LeaveWindow>:     leftWindow()            \n\
  110.      <BtnMotion>:       highlight()             \n\
  111.      <BtnUp>:           saveUnhighlight() MenuPopdown()"; 
  112.  
  113. /*
  114.  * Semi Public function definitions. 
  115.  */
  116.  
  117. static void Redisplay(Widget, XEvent *, Region);
  118. static void Realize(Widget, XtValueMask *, XSetWindowAttributes *);
  119. static void ChangeManaged(Widget);
  120. static void Resize(Widget);
  121. static void Initialize(Widget, Widget, ArgList, Cardinal *);
  122. static void ClassInitialize(void);
  123. static void ClassPartInitialize(WidgetClass);
  124. static Boolean SetValues(Widget, Widget, Widget, ArgList, Cardinal *);
  125. static Boolean SetValuesHook(Widget, ArgList, Cardinal *);
  126. static XtGeometryResult GeometryManager(Widget, XtWidgetGeometry *,
  127.     XtWidgetGeometry *);
  128.  
  129. /*
  130.  * Action Routine Definitions
  131.  */
  132.  
  133. static void PositionMenuAction(Widget, XEvent *, String *, Cardinal *);
  134. static void SaveUnhighlight(Widget, XEvent *, String *, Cardinal *);
  135. static void LeftWindow(Widget, XEvent *, String *, Cardinal *);
  136. static void Highlight(Widget, XEvent *, String *, Cardinal *);
  137.  
  138. /* 
  139.  * Private Function Definitions.
  140.  */
  141.  
  142. static void Unhighlight(), Notify();
  143. static void MakeSetValuesRequest(Widget, Dimension, Dimension);
  144. static void Layout(Widget, Dimension *, Dimension *);
  145. static void CreateLabel(Widget);
  146. static void AddPositionAction(XtAppContext, caddr_t);
  147. static void ChangeCursorOnGrab(Widget, XtPointer junk, XtPointer);
  148. static void PositionMenu(Widget, XPoint *);
  149. static void ClearParent(Widget, XtPointer, XtPointer);
  150. static Dimension GetMenuWidth(Widget, Widget);
  151. static Dimension GetMenuHeight(Widget);
  152. static Widget FindMenu(Widget, String);
  153. static CmeObject GetEventEntry(Widget, XEvent *);
  154. static CmeObject GetRightEntry(Widget, XEvent *);
  155. static void MoveMenu(Widget, Position, Position);
  156.  
  157. static XtActionsRec actionsList[] =
  158. {
  159.   {"highlight",         Highlight},
  160.   {"saveUnhighlight",   SaveUnhighlight},
  161.   {"leftWindow",    LeftWindow},
  162. };
  163.  
  164. static CompositeClassExtensionRec extension_rec = {
  165.     /* next_extension */  NULL,
  166.     /* record_type */     NULLQUARK,
  167.     /* version */         XtCompositeExtensionVersion,
  168.     /* record_size */     sizeof(CompositeClassExtensionRec),
  169.     /* accepts_objects */ TRUE,
  170. };
  171.  
  172. #define superclass (&overrideShellClassRec)
  173.     
  174. ComplexMenuClassRec complexMenuClassRec = {
  175.   {
  176.     /* superclass         */    (WidgetClass) superclass,
  177.     /* class_name         */    "ComplexMenu",
  178.     /* size               */    sizeof(ComplexMenuRec),
  179.     /* class_initialize   */    ClassInitialize,
  180.     /* class_part_initialize*/    ClassPartInitialize,
  181.     /* Class init'ed      */    FALSE,
  182.     /* initialize         */    Initialize,
  183.     /* initialize_hook    */    NULL,
  184.     /* realize            */    Realize,
  185.     /* actions            */    actionsList,
  186.     /* num_actions        */    XtNumber(actionsList),
  187.     /* resources          */    resources,
  188.     /* resource_count     */    XtNumber(resources),
  189.     /* xrm_class          */    NULLQUARK,
  190.     /* compress_motion    */    TRUE, 
  191.     /* compress_exposure  */    TRUE,
  192.     /* compress_enterleave*/     TRUE,
  193.     /* visible_interest   */    FALSE,
  194.     /* destroy            */    NULL,
  195.     /* resize             */    Resize,
  196.     /* expose             */    Redisplay,
  197.     /* set_values         */    SetValues,
  198.     /* set_values_hook    */    SetValuesHook,
  199.     /* set_values_almost  */    XtInheritSetValuesAlmost,  
  200.     /* get_values_hook    */    NULL,            
  201.     /* accept_focus       */    NULL,
  202.     /* intrinsics version */    XtVersion,
  203.     /* callback offsets   */    NULL,
  204.     /* tm_table          */    defaultTranslations,
  205.     /* query_geometry      */    NULL,
  206.     /* display_accelerator*/    NULL,
  207.     /* extension      */    NULL
  208.   },{
  209.     /* geometry_manager   */    GeometryManager,
  210.     /* change_managed     */    ChangeManaged,
  211.     /* insert_child      */    XtInheritInsertChild,
  212.     /* delete_child      */    XtInheritDeleteChild,
  213.     /* extension      */    NULL
  214.   },{
  215.     /* Shell extension      */    NULL
  216.   },{
  217.     /* Override extension */    NULL
  218.   },{
  219.     /* Complex Menu extension*/  NULL
  220.   }
  221. };
  222.  
  223. WidgetClass complexMenuWidgetClass = (WidgetClass)&complexMenuClassRec;
  224.  
  225. /************************************************************
  226.  *
  227.  * Semi-Public Functions.
  228.  *
  229.  ************************************************************/
  230.  
  231. /*      Function Name: ClassInitialize
  232.  *      Description: Class Initialize routine, called only once.
  233.  *      Arguments: none.
  234.  *      Returns: none.
  235.  */
  236.  
  237. static void
  238. ClassInitialize(void)
  239. {
  240.   XawInitializeWidgetSet();
  241.   XtAddConverter( XtRString, XtRBackingStore, XmuCvtStringToBackingStore,
  242.          NULL, 0 );
  243.   XmuAddInitializer( AddPositionAction, NULL);
  244. }
  245.  
  246. /*      Function Name: ClassInitialize
  247.  *      Description: Class Part Initialize routine, called for every
  248.  *                   subclass.  Makes sure that the subclasses pick up 
  249.  *                   the extension record.
  250.  *      Arguments: wc - the widget class of the subclass.
  251.  *      Returns: none.
  252.  */
  253.  
  254. static void
  255. ClassPartInitialize(WidgetClass wc)
  256. {
  257.     ComplexMenuWidgetClass cmwc = (ComplexMenuWidgetClass) wc;
  258.  
  259. /*
  260.  * Make sure that our subclass gets the extension rec too.
  261.  */
  262.  
  263.     extension_rec.next_extension = cmwc->composite_class.extension;
  264.     cmwc->composite_class.extension = (XtPointer) &extension_rec;
  265. }
  266.  
  267. /*      Function Name: Initialize
  268.  *      Description: Initializes the complex menu widget
  269.  *      Arguments: request - the widget requested by the argument list.
  270.  *                 new     - the new widget with both resource and non
  271.  *                           resource values.
  272.  *      Returns: none.
  273.  */
  274.  
  275. static void
  276. Initialize(Widget request unused, Widget new, ArgList args unused,
  277.     Cardinal *num_args unused)
  278. {
  279.   ComplexMenuWidget cmw = (ComplexMenuWidget) new;
  280.  
  281.   XmuCallInitializers(XtWidgetToApplicationContext(new));
  282.  
  283.   if (cmw->complex_menu.label_class == NULL) 
  284.       cmw->complex_menu.label_class = cmeBSBObjectClass;
  285.  
  286.   cmw->complex_menu.label = NULL;
  287.   cmw->complex_menu.entry_set = NULL;
  288.   cmw->complex_menu.prev_entry = NULL;
  289.   cmw->complex_menu.recursive_set_values = FALSE;
  290.  
  291.   if (cmw->complex_menu.label_string != NULL)
  292.       CreateLabel(new);
  293.  
  294.   cmw->complex_menu.menu_width = TRUE;
  295.  
  296.   if (cmw->core.width == 0) {
  297.       cmw->complex_menu.menu_width = FALSE;
  298.       cmw->core.width = GetMenuWidth(new, (Widget)NULL);
  299.   }
  300.  
  301.   cmw->complex_menu.menu_height = TRUE;
  302.  
  303.   if (cmw->core.height == 0) {
  304.       cmw->complex_menu.menu_height = FALSE;
  305.       cmw->core.height = GetMenuHeight(new);
  306.   }
  307.  
  308. /*
  309.  * Add a popup_callback routine for changing the cursor.
  310.  */
  311.   
  312.   XtAddCallback(new, XtNpopupCallback, ChangeCursorOnGrab, NULL);
  313.  
  314. /*
  315.  * Add a popdown_callback routine for clearing the parent field.
  316.  */
  317.   
  318.   XtAddCallback(new, XtNpopdownCallback, ClearParent, NULL);
  319. }
  320.  
  321. /*      Function Name: Redisplay
  322.  *      Description: Redisplays the contents of the widget.
  323.  *      Arguments: w - the complex menu widget.
  324.  *                 event - the X event that caused this redisplay.
  325.  *                 region - the region the needs to be repainted. 
  326.  *      Returns: none.
  327.  */
  328.  
  329. static void
  330. Redisplay(Widget w, XEvent *event unused, Region region)
  331. {
  332.     ComplexMenuWidget cmw = (ComplexMenuWidget) w;
  333.     CmeObject * entry;
  334.     CmeObjectClass class;
  335.  
  336.     if (region == NULL)
  337.     XClearWindow(XtDisplay(w), XtWindow(w));
  338.  
  339.     /*
  340.      * Check and Paint each of the entries - including the label.
  341.      */
  342.  
  343.     ForAllChildren(cmw, entry) {
  344.     if (!XtIsManaged ( (Widget) *entry)) continue;
  345.  
  346.     if (region != NULL) 
  347.         switch(XRectInRegion(region, (int) (*entry)->rectangle.x,
  348.                  (int) (*entry)->rectangle.y,
  349.                  (unsigned int) (*entry)->rectangle.width,
  350.                  (unsigned int) (*entry)->rectangle.height)) {
  351.         case RectangleIn:
  352.         case RectanglePart:
  353.         break;
  354.         default:
  355.         continue;
  356.         }
  357.     class = (CmeObjectClass) (*entry)->object.widget_class;
  358.  
  359.     if (class->rect_class.expose != NULL)
  360.         (class->rect_class.expose)( (Widget) *entry, NULL, NULL);
  361.     }
  362. }
  363.  
  364. /*      Function Name: Realize
  365.  *      Description: Realizes the widget.
  366.  *      Arguments: w - the complex menu widget.
  367.  *                 mask - value mask for the window to create.
  368.  *                 attrs - attributes for the window to create.
  369.  *      Returns: none
  370.  */
  371.  
  372. static void
  373. Realize(Widget w, XtValueMask *mask, XSetWindowAttributes *attrs)
  374. {
  375.     ComplexMenuWidget cmw = (ComplexMenuWidget) w;
  376.  
  377.     attrs->cursor = cmw->complex_menu.cursor;
  378.     *mask |= CWCursor;
  379.     if ((cmw->complex_menu.backing_store == Always) ||
  380.     (cmw->complex_menu.backing_store == NotUseful) ||
  381.     (cmw->complex_menu.backing_store == WhenMapped) ) {
  382.     *mask |= CWBackingStore;
  383.     attrs->backing_store = cmw->complex_menu.backing_store;
  384.     }
  385.     else
  386.     *mask &= ~CWBackingStore;
  387.  
  388.     (*superclass->core_class.realize) (w, mask, attrs);
  389. }
  390.  
  391. /*      Function Name: Resize
  392.  *      Description: Handle the menu being resized bigger.
  393.  *      Arguments: w - the complex menu widget.
  394.  *      Returns: none.
  395.  */
  396.  
  397. static void
  398. Resize(Widget w)
  399. {
  400.     ComplexMenuWidget cmw = (ComplexMenuWidget) w;
  401.     CmeObject * entry;
  402.  
  403.     if ( !XtIsRealized(w) ) return;
  404.  
  405.     ForAllChildren(cmw, entry)     /* reset width of all entries. */
  406.     if (XtIsManaged( (Widget) *entry))
  407.         (*entry)->rectangle.width = cmw->core.width;
  408.     
  409.     Redisplay(w, (XEvent *) NULL, (Region) NULL);
  410. }
  411.  
  412. /*      Function Name: SetValues
  413.  *      Description: Relayout the menu when one of the resources is changed.
  414.  *      Arguments: current - current state of the widget.
  415.  *                 request - what was requested.
  416.  *                 new - what the widget will become.
  417.  *      Returns: none
  418.  */
  419.  
  420. static Boolean
  421. SetValues(Widget current, Widget request unused, Widget new,
  422.     ArgList args unused, Cardinal *num_args unused)
  423. {
  424.     ComplexMenuWidget cmw_old = (ComplexMenuWidget) current;
  425.     ComplexMenuWidget cmw_new = (ComplexMenuWidget) new;
  426.     Boolean ret_val = FALSE, layout = FALSE;
  427.     
  428.     if (!XtIsRealized(current)) return(FALSE);
  429.     
  430.     if (!cmw_new->complex_menu.recursive_set_values) {
  431.     if (cmw_new->core.width != cmw_old->core.width) {
  432.         cmw_new->complex_menu.menu_width = (cmw_new->core.width != 0);
  433.         layout = TRUE;
  434.     }
  435.     if (cmw_new->core.height != cmw_old->core.height) {
  436.         cmw_new->complex_menu.menu_height = (cmw_new->core.height != 0);
  437.         layout = TRUE;
  438.     }
  439.     }
  440.  
  441.     if (cmw_old->complex_menu.cursor != cmw_new->complex_menu.cursor)
  442.     XDefineCursor(XtDisplay(new),
  443.               XtWindow(new), cmw_new->complex_menu.cursor);
  444.     
  445.     if (cmw_old->complex_menu.label_string !=cmw_new->complex_menu.label_string) { 
  446.     if (cmw_new->complex_menu.label_string == NULL)         /* Destroy. */
  447.         XtDestroyWidget((Widget) cmw_old->complex_menu.label);
  448.     else if (cmw_old->complex_menu.label_string == NULL)    /* Create. */
  449.         CreateLabel(new);
  450.     else {                                                 /* Change. */
  451.         Arg arglist[1];
  452.         
  453.         XtSetArg(arglist[0], XtNlabel, cmw_new->complex_menu.label_string);
  454.         XtSetValues((Widget) cmw_new->complex_menu.label, arglist, ONE);
  455.     }
  456.     }
  457.     
  458.     if (cmw_old->complex_menu.label_class != cmw_new->complex_menu.label_class)
  459.     XtAppWarning(XtWidgetToApplicationContext(new),
  460.              "No Dynamic class change of the ComplexMenu Label.");
  461.     
  462.     if ((cmw_old->complex_menu.top_margin != cmw_new->complex_menu.top_margin) ||
  463.     (cmw_old->complex_menu.bottom_margin != 
  464.      cmw_new->complex_menu.bottom_margin) /* filler.................  */ ) {
  465.     layout = TRUE;
  466.     ret_val = TRUE;
  467.     }
  468.  
  469.     if (layout)
  470.     Layout(new, (Dimension *)NULL, (Dimension *)NULL);
  471.  
  472.     return(ret_val);
  473. }
  474.  
  475. /*      Function Name: SetValuesHook
  476.  *      Description: To handle a special case, this is passed the
  477.  *                   actual arguments.
  478.  *      Arguments: w - the menu widget.
  479.  *                 arglist - the argument list passed to XtSetValues.
  480.  *                 num_args - the number of args.
  481.  *      Returns: none
  482.  */
  483.  
  484. /* 
  485.  * If the user actually passed a width and height to the widget
  486.  * then this MUST be used, rather than our newly calculated width and
  487.  * height.
  488.  */
  489.  
  490. static Boolean
  491. SetValuesHook(Widget w, ArgList arglist, Cardinal *num_args)
  492. {
  493.     register Cardinal i;
  494.     Dimension width, height;
  495.     
  496.     width = w->core.width;
  497.     height = w->core.height;
  498.     
  499.     for ( i = 0 ; i < *num_args ; i++) {
  500.     if ( streq(arglist[i].name, XtNwidth) )
  501.         width = (Dimension) arglist[i].value;
  502.     if ( streq(arglist[i].name, XtNheight) )
  503.         height = (Dimension) arglist[i].value;
  504.     }
  505.  
  506.     if ((width != w->core.width) || (height != w->core.height))
  507.     MakeSetValuesRequest(w, width, height);
  508.     return(FALSE);
  509. }
  510.  
  511. /************************************************************
  512.  *
  513.  * Geometry Management routines.
  514.  *
  515.  ************************************************************/
  516.  
  517. /*    Function Name: GeometryManager
  518.  *    Description: This is the ComplexMenu Widget's Geometry Manager.
  519.  *    Arguments: w - the Menu Entry making the request.
  520.  *                 request - requested new geometry.
  521.  *                 reply - the allowed geometry.
  522.  *    Returns: XtGeometry{Yes, No, Almost}.
  523.  */
  524.  
  525. static XtGeometryResult
  526. GeometryManager(Widget w, XtWidgetGeometry *request, XtWidgetGeometry *reply)
  527. {
  528.     ComplexMenuWidget cmw = (ComplexMenuWidget) XtParent(w);
  529.     CmeObject entry = (CmeObject) w;
  530.     XtGeometryMask mode = request->request_mode;
  531.     XtGeometryResult answer;
  532.     Dimension old_height, old_width;
  533.  
  534.     if ( !(mode & CWWidth) && !(mode & CWHeight) )
  535.     return(XtGeometryNo);
  536.  
  537.     reply->width = request->width;
  538.     reply->height = request->height;
  539.  
  540.     old_width = entry->rectangle.width;
  541.     old_height = entry->rectangle.height;
  542.  
  543.     Layout(w, &(reply->width), &(reply->height) );
  544.  
  545. /*
  546.  * Since we are an override shell and have no parent there is no one to
  547.  * ask to see if this geom change is okay, so I am just going to assume
  548.  * we can do whatever we want.  If you subclass be very careful with this
  549.  * assumption, it could bite you.
  550.  *
  551.  * Chris D. Peterson - Sept. 1989.
  552.  */
  553.  
  554.     if ( (reply->width == request->width) &&
  555.      (reply->height == request->height) ) {
  556.  
  557.     if ( mode & XtCWQueryOnly ) { /* Actually perform the layout. */
  558.         entry->rectangle.width = old_width;
  559.         entry->rectangle.height = old_height;    
  560.     }
  561.     else {
  562.         Layout(( Widget) cmw, (Dimension *)NULL, (Dimension *)NULL);
  563.     }
  564.     answer = XtGeometryDone;
  565.     }
  566.     else {
  567.     entry->rectangle.width = old_width;
  568.     entry->rectangle.height = old_height;    
  569.  
  570.     if ( ((reply->width == request->width) && !(mode & CWHeight)) ||
  571.           ((reply->height == request->height) && !(mode & CWWidth)) ||
  572.           ((reply->width == request->width) && 
  573.            (reply->height == request->height)) )
  574.         answer = XtGeometryNo;
  575.     else {
  576.         answer = XtGeometryAlmost;
  577.         reply->request_mode = 0;
  578.         if (reply->width != request->width)
  579.         reply->request_mode |= CWWidth;
  580.         if (reply->height != request->height)
  581.         reply->request_mode |= CWHeight;
  582.     }
  583.     }
  584.     return(answer);
  585. }
  586.  
  587. /*    Function Name: ChangeManaged
  588.  *    Description: called whenever a new child is managed.
  589.  *    Arguments: w - the complex menu widget.
  590.  *    Returns: none.
  591.  */
  592.  
  593. static void
  594. ChangeManaged(Widget w)
  595. {
  596.     Layout(w, (Dimension *)NULL, (Dimension *)NULL);
  597. }
  598.  
  599. /************************************************************
  600.  *
  601.  * Global Action Routines.
  602.  * 
  603.  * These actions routines will be added to the application's
  604.  * global action list. 
  605.  * 
  606.  ************************************************************/
  607.  
  608. /*      Function Name: PositionMenuAction
  609.  *      Description: Positions the complex menu widget.
  610.  *      Arguments: w - a widget (no the complex menu widget.)
  611.  *                 event - the event that caused this action.
  612.  *                 params, num_params - parameters passed to the routine.
  613.  *                                      we expect the name of the menu here.
  614.  *      Returns: none
  615.  */
  616.  
  617. static void
  618. PositionMenuAction(Widget w, XEvent *event, String *params,
  619.     Cardinal *num_params)
  620. { 
  621.   Widget menu;
  622.   XPoint loc;
  623.  
  624.   if (*num_params != 1) {
  625.     char error_buf[BUFSIZ];
  626.     (void) sprintf(error_buf, "%s %s",
  627.         "Xaw - ComplexMenuWidget: position menu action expects only one",
  628.         "parameter which is the name of the menu.");
  629.     XtAppWarning(XtWidgetToApplicationContext(w), error_buf);
  630.     return;
  631.   }
  632.  
  633.   if ( (menu = FindMenu(w, params[0])) == NULL) {
  634.     char error_buf[BUFSIZ];
  635.     (void) sprintf(error_buf, "%s '%s'",
  636.         "Xaw - ComplexMenuWidget: could not find menu named: ", params[0]);
  637.     XtAppWarning(XtWidgetToApplicationContext(w), error_buf);
  638.     return;
  639.   }
  640.   
  641.   switch (event->type) {
  642.   case ButtonPress:
  643.   case ButtonRelease:
  644.     loc.x = event->xbutton.x_root;
  645.     loc.y = event->xbutton.y_root;
  646.     PositionMenu(menu, &loc);
  647.     break;
  648.   case EnterNotify:
  649.   case LeaveNotify:
  650.     loc.x = event->xcrossing.x_root;
  651.     loc.y = event->xcrossing.y_root;
  652.     PositionMenu(menu, &loc);
  653.     break;
  654.   case MotionNotify:
  655.     loc.x = event->xmotion.x_root;
  656.     loc.y = event->xmotion.y_root;
  657.     PositionMenu(menu, &loc);
  658.     break;
  659.   default:
  660.     PositionMenu(menu, (XPoint *)NULL);
  661.     break;
  662.   }
  663. }  
  664.  
  665. /************************************************************
  666.  *
  667.  * Widget Action Routines.
  668.  * 
  669.  ************************************************************/
  670.  
  671. /*      Function Name: Unhighlight
  672.  *      Description: Unhighlights current entry.
  673.  *      Arguments: w - the complex menu widget.
  674.  *                 event - the event that caused this action.
  675.  *                 params, num_params - ** NOT USED **
  676.  *      Returns: none
  677.  */
  678.  
  679. static void
  680. Unhighlight(Widget w, XEvent *event unused, String *params unused,
  681.     Cardinal *num_params unused)
  682. { 
  683.     ComplexMenuWidget cmw = (ComplexMenuWidget) w;
  684.     CmeObject entry = cmw->complex_menu.entry_set;
  685.     CmeObjectClass class;
  686.  
  687.     if ( entry == NULL) return;
  688.  
  689.     cmw->complex_menu.entry_set = NULL;
  690.     class = (CmeObjectClass) entry->object.widget_class;
  691.     (class->cme_class.unhighlight) ( (Widget) entry);
  692. }
  693.  
  694. static void
  695. SaveUnhighlight(Widget w, XEvent *event unused, String *params unused,
  696.     Cardinal *num_params unused)
  697. { 
  698.     ComplexMenuWidget cmw = (ComplexMenuWidget) w;
  699.     CmeObject entry = cmw->complex_menu.entry_set;
  700.     CmeObjectClass class;
  701.  
  702.     if ( entry == NULL) return;
  703.  
  704.     cmw->complex_menu.prev_entry = entry;
  705.     cmw->complex_menu.entry_set = NULL;
  706.     class = (CmeObjectClass) entry->object.widget_class;
  707.     (class->cme_class.unhighlight) ( (Widget) entry);
  708. }
  709.  
  710. /*      Function Name: LeftWindow
  711.  *      Description: Mouse has left window, usually this means unhighlight
  712.  *      Arguments: w - the complex menu widget.
  713.  *                 event - the event that caused this action.
  714.  *                 params, num_params - ** NOT USED **
  715.  *      Returns: none
  716.  */
  717.  
  718. static void
  719. LeftWindow(Widget w, XEvent *event, String *params unused,
  720.     Cardinal *num_params unused)
  721. { 
  722.     ComplexMenuWidget cmw = (ComplexMenuWidget) w;
  723.     CmeObject entry = cmw->complex_menu.entry_set;
  724.     CmeObjectClass class;
  725.     String mn;
  726.  
  727.     if ( entry == NULL) return;
  728.  
  729.     mn = NULL;
  730.     XtVaGetValues((Widget) entry, XtNmenuName, &mn, NULL);
  731.     if (mn != NULL && GetRightEntry(w, event) == entry)
  732.     return;
  733.  
  734.     cmw->complex_menu.prev_entry = NULL;
  735.     cmw->complex_menu.entry_set = NULL;
  736.     class = (CmeObjectClass) entry->object.widget_class;
  737.     (class->cme_class.unhighlight) ( (Widget) entry);
  738. }
  739.  
  740. /*      Function Name: Highlight
  741.  *      Description: Highlights current entry.
  742.  *      Arguments: w - the complex menu widget.
  743.  *                 event - the event that caused this action.
  744.  *                 params, num_params - ** NOT USED **
  745.  *      Returns: none
  746.  */
  747.  
  748. static void
  749. Highlight(Widget w, XEvent *event, String *params, Cardinal *num_params)
  750. {
  751.     ComplexMenuWidget cmw = (ComplexMenuWidget) w;
  752.     CmeObject entry;
  753.     CmeObjectClass class;
  754.     ShellWidget shell_widget = (ShellWidget)w;
  755.  
  756.     
  757. #if defined(CmeDebug)
  758.     printf("Highlight(%x)\n", w);
  759. #endif
  760.  
  761.     if (shell_widget->shell.popped_up != TRUE) {
  762. #if defined(CmeDebug)
  763.     printf("bogus\n");
  764. #endif
  765.     return;
  766.     }
  767.  
  768.     if ( !XtIsSensitive(w) ) return;
  769.     
  770.     entry = GetEventEntry(w, event);
  771.  
  772.     if (entry == cmw->complex_menu.entry_set) return;
  773.  
  774.     Unhighlight(w, event, params, num_params);  
  775.  
  776.     if (entry == NULL) return;
  777.  
  778.     if ( !XtIsSensitive( (Widget) entry)) {
  779.     cmw->complex_menu.entry_set = NULL;
  780.     return;
  781.     }
  782.  
  783.     cmw->complex_menu.entry_set = entry;
  784.     class = (CmeObjectClass) entry->object.widget_class;
  785.  
  786.     (class->cme_class.highlight) ( (Widget) entry);
  787. }
  788.  
  789. /*      Function Name: Notify
  790.  *      Description: Notify user of current entry.
  791.  *      Arguments: w - the complex menu widget.
  792.  *                 event - the event that caused this action.
  793.  *                 params, num_params - ** NOT USED **
  794.  *      Returns: none
  795.  */
  796.  
  797. static void
  798. Notify(Widget w, XEvent *event unused, String *params unused,
  799.     Cardinal *num_params unused)
  800. {
  801.     ComplexMenuWidget cmw = (ComplexMenuWidget) w;
  802.     CmeObject entry = cmw->complex_menu.entry_set;
  803.     CmeObjectClass class;
  804.     
  805.     if (entry == NULL)
  806.     entry = cmw->complex_menu.prev_entry;
  807.     if ( (entry == NULL) || !XtIsSensitive((Widget) entry) ) return;
  808.  
  809.     if (cmw->complex_menu.parent != NULL) {
  810. #if defined(CmeDebug)
  811.     printf("Notify(%x): deferring to %x to parent %x\n", w, entry,
  812.         cmw->complex_menu.parent);
  813. #endif
  814.     XtVaSetValues(cmw->complex_menu.parent, XtNcMdefer, (Widget)entry,
  815.         NULL);
  816.     return;
  817.     }
  818. #if defined(CmeDebug)
  819.     else
  820.     printf("Notify(%x): not deferring\n", w);
  821. #endif
  822.     if (cmw->complex_menu.deferred_notify != NULL) {
  823. #if defined(CmeDebug)
  824.     printf("Notify: using deferred %x\n", w,
  825.         cmw->complex_menu.deferred_notify);
  826. #endif
  827.     entry = (CmeObject)cmw->complex_menu.deferred_notify;
  828.     }
  829.     class = (CmeObjectClass) entry->object.widget_class;
  830.     (class->cme_class.notify)( (Widget) entry );
  831. }
  832.  
  833. /************************************************************
  834.  *
  835.  * Public Functions.
  836.  *
  837.  ************************************************************/
  838.  
  839. /*    Function Name: XawComplexMenuAddGlobalActions
  840.  *    Description: adds the global actions to the complex menu widget.
  841.  *    Arguments: app_con - the appcontext.
  842.  *    Returns: none.
  843.  */
  844.  
  845. void
  846. XawComplexMenuAddGlobalActions(XtAppContext app_con)
  847. {
  848.     XtInitializeWidgetClass(complexMenuWidgetClass);
  849.     XmuCallInitializers( app_con );
  850. } 
  851.  
  852.  
  853. /*    Function Name: XawComplexMenuGetActiveEntry
  854.  *    Description: Gets the currently active (set) entry.
  855.  *    Arguments: w - the cmw widget.
  856.  *    Returns: the currently set entry or NULL if none is set.
  857.  */
  858.  
  859. Widget
  860. XawComplexMenuGetActiveEntry(Widget w)
  861. {
  862.     ComplexMenuWidget cmw = (ComplexMenuWidget) w;
  863.  
  864.     return( (Widget) cmw->complex_menu.entry_set);
  865. } 
  866.  
  867. /*    Function Name: XawComplexMenuClearActiveEntry
  868.  *    Description: Unsets the currently active (set) entry.
  869.  *    Arguments: w - the cmw widget.
  870.  *    Returns: none.
  871.  */
  872.  
  873. void
  874. XawComplexMenuClearActiveEntry(Widget w)
  875. {
  876.     ComplexMenuWidget cmw = (ComplexMenuWidget) w;
  877.  
  878.     cmw->complex_menu.entry_set = NULL;
  879.     cmw->complex_menu.prev_entry = NULL;
  880. } 
  881.  
  882. /************************************************************
  883.  *
  884.  * Private Functions.
  885.  *
  886.  ************************************************************/
  887.  
  888. /*    Function Name: CreateLabel
  889.  *    Description: Creates a the menu label.
  890.  *    Arguments: w - the cmw widget.
  891.  *    Returns: none.
  892.  * 
  893.  * Creates the label object and makes sure it is the first child in
  894.  * in the list.
  895.  */
  896.  
  897. static void
  898. CreateLabel(Widget w)
  899. {
  900.     ComplexMenuWidget cmw = (ComplexMenuWidget) w;
  901.     register Widget * child, * next_child;
  902.     register int i;
  903.     Arg args[2];
  904.  
  905.     if ( (cmw->complex_menu.label_string == NULL) ||
  906.      (cmw->complex_menu.label != NULL) ) {
  907.     char error_buf[BUFSIZ];
  908.  
  909.     (void) sprintf(error_buf, "Xaw Complex Menu Widget: %s or %s, %s",
  910.         "label string is NULL", "label already exists", 
  911.         "no label is being created.");
  912.     XtAppWarning(XtWidgetToApplicationContext(w), error_buf);
  913.     return;
  914.     }
  915.  
  916.     XtSetArg(args[0], XtNlabel, cmw->complex_menu.label_string);
  917.     XtSetArg(args[1], XtNjustify, XtJustifyCenter);
  918.     cmw->complex_menu.label = (CmeObject) 
  919.                           XtCreateManagedWidget("menuLabel", 
  920.                         cmw->complex_menu.label_class, w,
  921.                         args, TWO);
  922.  
  923.     next_child = NULL;
  924.     for (child = cmw->composite.children + cmw->composite.num_children,
  925.      i = cmw->composite.num_children ; i > 0 ; i--, child--) {
  926.     if (next_child != NULL)
  927.         *next_child = *child;
  928.     next_child = child;
  929.     }
  930.     *child = (Widget) cmw->complex_menu.label;
  931. }
  932.  
  933. /*    Function Name: Layout
  934.  *    Description: lays the menu entries out all nice and neat.
  935.  *    Arguments: w - See below (+++)
  936.  *                 width_ret, height_ret - The returned width and 
  937.  *                                         height values.
  938.  *    Returns: none.
  939.  *
  940.  * if width == NULL || height == NULL then it assumes the you do not care
  941.  * about the return values, and just want a relayout.
  942.  *
  943.  * if this is not the case then it will set width_ret and height_ret
  944.  * to be width and height that the child would get if it were layed out
  945.  * at this time.
  946.  *
  947.  * +++ "w" can be the complex menu widget or any of its object children.
  948.  */
  949.  
  950. static void
  951. Layout(Widget w, Dimension *width_ret, Dimension *height_ret)
  952. {
  953.     CmeObject current_entry, *entry;
  954.     ComplexMenuWidget cmw;
  955.     Dimension width, height;
  956.     Boolean do_layout = ((height_ret == NULL) || (width_ret == NULL));
  957.     Boolean allow_change_size;
  958.     height = 0;
  959.  
  960.     if ( XtIsSubclass(w, complexMenuWidgetClass) ) {
  961.     cmw = (ComplexMenuWidget) w;
  962.     current_entry = NULL;
  963.     }
  964.     else {
  965.     cmw = (ComplexMenuWidget) XtParent(w);
  966.     current_entry = (CmeObject) w;
  967.     }
  968.  
  969.     allow_change_size = (!XtIsRealized((Widget)cmw) ||
  970.              (cmw->shell.allow_shell_resize));
  971.  
  972.     if ( cmw->complex_menu.menu_height )
  973.     height = cmw->core.height;
  974.     else
  975.     if (do_layout) {
  976.         height = cmw->complex_menu.top_margin;
  977.         ForAllChildren(cmw, entry) {
  978.         if (!XtIsManaged( (Widget) *entry)) continue;
  979.  
  980.         if ( (cmw->complex_menu.row_height != 0) && 
  981.             (*entry != cmw->complex_menu.label) ) 
  982.             (*entry)->rectangle.height = cmw->complex_menu.row_height;
  983.         
  984.         (*entry)->rectangle.y = height;
  985.         (*entry)->rectangle.x = 0;
  986.         height += (*entry)->rectangle.height;
  987.         }
  988.         height += cmw->complex_menu.bottom_margin;
  989.     }
  990.     else {
  991.         if ((cmw->complex_menu.row_height != 0) && 
  992.         (current_entry != cmw->complex_menu.label) )
  993.         height = cmw->complex_menu.row_height;
  994.     }
  995.     
  996.     if (cmw->complex_menu.menu_width)
  997.     width = cmw->core.width;
  998.     else if ( allow_change_size )
  999.     width = GetMenuWidth((Widget) cmw, (Widget) current_entry);
  1000.     else
  1001.     width = cmw->core.width;
  1002.  
  1003.     if (do_layout) {
  1004.     ForAllChildren(cmw, entry)
  1005.         if (XtIsManaged( (Widget) *entry)) 
  1006.         (*entry)->rectangle.width = width;
  1007.  
  1008.     if (allow_change_size)
  1009.         MakeSetValuesRequest((Widget) cmw, width, height);
  1010.     }
  1011.     else {
  1012.     *width_ret = width;
  1013.     if (height != 0)
  1014.         *height_ret = height;
  1015.     }
  1016. }
  1017.     
  1018. /*    Function Name: AddPositionAction
  1019.  *    Description: Adds the XawPositionComplexMenu action to the global
  1020.  *                   action list for this appcon.
  1021.  *    Arguments: app_con - the application context for this app.
  1022.  *                 data - NOT USED.
  1023.  *    Returns: none.
  1024.  */
  1025.  
  1026. static void
  1027. AddPositionAction(XtAppContext app_con, caddr_t data unused)
  1028. {
  1029.     static XtActionsRec pos_action[] = {
  1030.         { "XawPositionComplexMenu", PositionMenuAction },
  1031.     };
  1032.  
  1033.     XtAppAddActions(app_con, pos_action, XtNumber(pos_action));
  1034. }
  1035.  
  1036. /*    Function Name: FindMenu
  1037.  *    Description: Find the menu give a name and reference widget.
  1038.  *    Arguments: widget - reference widget.
  1039.  *                 name   - the menu widget's name.
  1040.  *    Returns: the menu widget or NULL.
  1041.  */
  1042.  
  1043. static Widget 
  1044. FindMenu(Widget widget, String name)
  1045. {
  1046.     register Widget w, menu;
  1047.     
  1048.     for ( w = widget ; w != NULL ; w = XtParent(w) )
  1049.     if ( (menu = XtNameToWidget(w, name)) != NULL )
  1050.         return(menu);
  1051.     return(NULL);
  1052. }
  1053.  
  1054. /*    Function Name: PositionMenu
  1055.  *    Description: Places the menu
  1056.  *    Arguments: w - the complex menu widget.
  1057.  *                 location - a pointer the the position or NULL.
  1058.  *    Returns: none.
  1059.  */
  1060.  
  1061. static void
  1062. PositionMenu(Widget w, XPoint *location)
  1063. {
  1064.     ComplexMenuWidget cmw = (ComplexMenuWidget) w;
  1065.     CmeObject entry;
  1066.     XPoint t_point;
  1067.     
  1068.     if (location == NULL) {
  1069.     Window junk1, junk2;
  1070.     int root_x, root_y, junkX, junkY;
  1071.     unsigned int junkM;
  1072.     
  1073.     location = &t_point;
  1074.     if (XQueryPointer(XtDisplay(w), XtWindow(w), &junk1, &junk2, 
  1075.               &root_x, &root_y, &junkX, &junkY, &junkM) == FALSE) {
  1076.         char error_buf[BUFSIZ];
  1077.         (void) sprintf(error_buf, "%s %s", "Xaw - ComplexMenuWidget:",
  1078.             "Could not find location of mouse pointer");
  1079.         XtAppWarning(XtWidgetToApplicationContext(w), error_buf);
  1080.         return;
  1081.     }
  1082.     location->x = (short) root_x;
  1083.     location->y = (short) root_y;
  1084.     }
  1085.     
  1086.     /*
  1087.      * The width will not be correct unless it is realized.
  1088.      */
  1089.     
  1090.     XtRealizeWidget(w);
  1091.     
  1092.     location->x -= (Position) w->core.width/2;
  1093.     
  1094.     if (cmw->complex_menu.popup_entry == NULL)
  1095.     entry = cmw->complex_menu.label;
  1096.     else
  1097.     entry = cmw->complex_menu.popup_entry;
  1098.  
  1099.     if (entry != NULL)
  1100.     location->y -= entry->rectangle.y + entry->rectangle.height/2;
  1101.  
  1102.     MoveMenu(w, (Position) location->x, (Position) location->y);
  1103. }
  1104.  
  1105. /*    Function Name: MoveMenu
  1106.  *    Description: Actually moves the menu, may force it to
  1107.  *                   to be fully visable if menu_on_screen is TRUE.
  1108.  *    Arguments: w - the complex menu widget.
  1109.  *                 x, y - the current location of the widget.
  1110.  *    Returns: none 
  1111.  */
  1112.  
  1113. static void
  1114. MoveMenu(Widget w, Position x, Position y)
  1115. {
  1116.     Arg arglist[2];
  1117.     Cardinal num_args = 0;
  1118.     ComplexMenuWidget cmw = (ComplexMenuWidget) w;
  1119.     
  1120.     if (cmw->complex_menu.menu_on_screen) {
  1121.     int width = w->core.width + 2 * w->core.border_width;
  1122.     int height = w->core.height + 2 * w->core.border_width;
  1123.     
  1124.     if (x >= 0) {
  1125.         int scr_width = WidthOfScreen(XtScreen(w));
  1126.         if (x + width > scr_width)
  1127.         x = scr_width - width;
  1128.     }
  1129.     if (x < 0) 
  1130.         x = 0;
  1131.     
  1132.     if (y >= 0) {
  1133.         int scr_height = HeightOfScreen(XtScreen(w));
  1134.         if (y + height > scr_height)
  1135.         y = scr_height - height;
  1136.     }
  1137.     if (y < 0)
  1138.         y = 0;
  1139.     }
  1140.     
  1141.     XtSetArg(arglist[num_args], XtNx, x); num_args++;
  1142.     XtSetArg(arglist[num_args], XtNy, y); num_args++;
  1143.     XtSetValues(w, arglist, num_args);
  1144. }
  1145.  
  1146. /*    Function Name: ChangeCursorOnGrab
  1147.  *    Description: Changes the cursor on the active grab to the one
  1148.  *                   specified in out resource list.
  1149.  *    Arguments: w - the widget.
  1150.  *                 junk, garbage - ** NOT USED **.
  1151.  *    Returns: None.
  1152.  */
  1153.  
  1154. static void
  1155. ChangeCursorOnGrab(Widget w, XtPointer junk unused, XtPointer garbage unused)
  1156. {
  1157.     ComplexMenuWidget cmw = (ComplexMenuWidget) w;
  1158.     
  1159. #if defined(CmeDebug)
  1160.     printf("ChangeCursorOnGrab(%x): parent=%x\n", w, cmw->complex_menu.parent);
  1161. #endif
  1162.     cmw->complex_menu.deferred_notify = NULL;
  1163.     cmw->complex_menu.prev_entry = NULL;
  1164.     
  1165.     /*
  1166.      * The event mask here is what is currently in the MIT implementation.
  1167.      * There really needs to be a way to get the value of the mask out
  1168.      * of the toolkit (CDP 5/26/89).
  1169.      */
  1170.     
  1171.     XChangeActivePointerGrab(XtDisplay(w), ButtonPressMask|ButtonReleaseMask,
  1172.                  cmw->complex_menu.cursor, 
  1173.                  XtLastTimestampProcessed(XtDisplay(w)));
  1174. }
  1175.  
  1176. static void
  1177. ClearParent(Widget w, XtPointer junk unused, XtPointer garbage unused)
  1178. {
  1179.     ComplexMenuWidget cmw = (ComplexMenuWidget) w;
  1180.     
  1181. #if defined(CmeDebug)
  1182.     printf("ClearParent(%x): parent=%x\n", w, cmw->complex_menu.parent);
  1183. #endif
  1184.     Notify(w, (XEvent *)NULL, (String *)NULL, (Cardinal *)NULL);
  1185.     cmw->complex_menu.parent = NULL;
  1186. }
  1187.  
  1188. /*      Function Name: MakeSetValuesRequest
  1189.  *      Description: Makes a (possibly recursive) call to SetValues,
  1190.  *                   I take great pains to not go into an infinite loop.
  1191.  *      Arguments: w - the complex menu widget.
  1192.  *                 width, height - the size of the ask for.
  1193.  *      Returns: none
  1194.  */
  1195.  
  1196. static void
  1197. MakeSetValuesRequest(Widget w, Dimension width, Dimension height)
  1198. {
  1199.     ComplexMenuWidget cmw = (ComplexMenuWidget) w;
  1200.     Arg arglist[2];
  1201.     Cardinal num_args = (Cardinal) 0;
  1202.     
  1203.     if ( !cmw->complex_menu.recursive_set_values ) {
  1204.     if ( (cmw->core.width != width) || (cmw->core.height != height) ) {
  1205.         cmw->complex_menu.recursive_set_values = TRUE;
  1206.         XtSetArg(arglist[num_args], XtNwidth, width);   num_args++;
  1207.         XtSetArg(arglist[num_args], XtNheight, height); num_args++;
  1208.         XtSetValues(w, arglist, num_args);
  1209.     }
  1210.     else if (XtIsRealized( (Widget) cmw))
  1211.         Redisplay((Widget) cmw, (XEvent *) NULL, (Region) NULL);
  1212.     }
  1213.     cmw->complex_menu.recursive_set_values = FALSE;
  1214. }
  1215.  
  1216. /*      Function Name: GetMenuWidth
  1217.  *      Description: Sets the length of the widest entry in pixels.
  1218.  *      Arguments: w - the complex menu widget.
  1219.  *      Returns: width of menu.
  1220.  */
  1221.  
  1222. static Dimension
  1223. GetMenuWidth(Widget w, Widget w_ent)
  1224. {
  1225.     CmeObject cur_entry = (CmeObject) w_ent;
  1226.     ComplexMenuWidget cmw = (ComplexMenuWidget) w;
  1227.     Dimension width, widest = (Dimension) 0;
  1228.     CmeObject * entry;
  1229.     
  1230.     if ( cmw->complex_menu.menu_width ) 
  1231.     return(cmw->core.width);
  1232.  
  1233.     ForAllChildren(cmw, entry) {
  1234.     XtWidgetGeometry preferred;
  1235.  
  1236.     if (!XtIsManaged( (Widget) *entry)) continue;
  1237.     
  1238.     if (*entry != cur_entry) {
  1239.         XtQueryGeometry((Widget) *entry, NULL, &preferred);
  1240.         
  1241.         if (preferred.request_mode & CWWidth)
  1242.         width = preferred.width;
  1243.         else
  1244.         width = (*entry)->rectangle.width;
  1245.     }
  1246.     else
  1247.         width = (*entry)->rectangle.width;
  1248.     
  1249.     if ( width > widest )
  1250.         widest = width;
  1251.     }
  1252.     
  1253.     return(widest);
  1254. }
  1255.  
  1256. /*      Function Name: GetMenuHeight
  1257.  *      Description: Sets the length of the widest entry in pixels.
  1258.  *      Arguments: w - the complex menu widget.
  1259.  *      Returns: width of menu.
  1260.  */
  1261.  
  1262. static Dimension
  1263. GetMenuHeight(Widget w)
  1264. {
  1265.     ComplexMenuWidget cmw = (ComplexMenuWidget) w;
  1266.     CmeObject * entry;
  1267.     Dimension height;
  1268.     
  1269.     if (cmw->complex_menu.menu_height)
  1270.     return(cmw->core.height);
  1271.  
  1272.     height = cmw->complex_menu.top_margin + cmw->complex_menu.bottom_margin;
  1273.     
  1274.     if (cmw->complex_menu.row_height == 0) {
  1275.     ForAllChildren(cmw, entry) 
  1276.         if (XtIsManaged ((Widget) *entry)) 
  1277.         height += (*entry)->rectangle.height;
  1278.     } else 
  1279.     height += cmw->complex_menu.row_height * cmw->composite.num_children;
  1280.     
  1281.     return(height);
  1282. }
  1283.  
  1284. /*      Function Name: GetEventEntry
  1285.  *      Description: Gets an entry given an event that has X and Y coords.
  1286.  *      Arguments: w - the complex menu widget.
  1287.  *                 event - the event.
  1288.  *      Returns: the entry that this point is in.
  1289.  */
  1290.  
  1291. static CmeObject
  1292. GetEventEntry(Widget w, XEvent *event)
  1293. {
  1294.     Position x_loc = 0, y_loc = 0;
  1295.     ComplexMenuWidget cmw = (ComplexMenuWidget) w;
  1296.     CmeObject * entry;
  1297.     
  1298.     switch (event->type) {
  1299.     case MotionNotify:
  1300.     x_loc = event->xmotion.x;
  1301.     y_loc = event->xmotion.y;
  1302.     break;
  1303.     case EnterNotify:
  1304.     case LeaveNotify:
  1305.     x_loc = event->xcrossing.x;
  1306.     y_loc = event->xcrossing.y;
  1307.     break;
  1308.     case ButtonPress:
  1309.     case ButtonRelease:
  1310.     x_loc = event->xbutton.x;
  1311.     y_loc = event->xbutton.y;
  1312.     break;
  1313.     default:
  1314.     XtAppError(XtWidgetToApplicationContext(w),
  1315.            "Unknown event type in GetEventEntry().");
  1316.     break;
  1317.     }
  1318.     
  1319.     if ( (x_loc < 0) || (x_loc >= (int)cmw->core.width) || (y_loc < 0) ||
  1320.     (y_loc >= (int)cmw->core.height) )
  1321.     return(NULL);
  1322.     
  1323.     ForAllChildren(cmw, entry) {
  1324.     if (!XtIsManaged ((Widget) *entry)) continue;
  1325.  
  1326.     if ( ((*entry)->rectangle.y < y_loc) &&
  1327.             ((*entry)->rectangle.y + (int) (*entry)->rectangle.height > y_loc) ) {
  1328.         if ( *entry == cmw->complex_menu.label )
  1329.         return(NULL);    /* cannot select the label. */
  1330.         else
  1331.         return(*entry);
  1332.         }
  1333.     }
  1334.     
  1335.     return(NULL);
  1336. }
  1337.  
  1338. /*      Function Name: GetRightEntry
  1339.  *      Description: Gets an entry given a crossing event that has X and Y
  1340.  *                   coords, unless it exited to the right.
  1341.  *      Arguments: w - the complex menu widget.
  1342.  *                 event - the event.
  1343.  *      Returns: the entry that this point is in.
  1344.  */
  1345.  
  1346. static CmeObject
  1347. GetRightEntry(Widget w, XEvent *event)
  1348. {
  1349.     Position x_loc, y_loc;
  1350.     ComplexMenuWidget cmw = (ComplexMenuWidget) w;
  1351.     CmeObject * entry;
  1352.  
  1353.     x_loc = event->xcrossing.x;
  1354.     y_loc = event->xcrossing.y;
  1355.  
  1356.     if ( (x_loc < 0) || /*(x_loc < (int)cmw->core.width) ||*/ (y_loc < 0) ||
  1357.     (y_loc >= (int)cmw->core.height) )
  1358.     return(NULL);
  1359.  
  1360.     ForAllChildren(cmw, entry) {
  1361.     if (!XtIsManaged ((Widget) *entry)) continue;
  1362.  
  1363.     if ( ((*entry)->rectangle.y < y_loc) &&
  1364.             ((*entry)->rectangle.y + (int) (*entry)->rectangle.height > y_loc) ) {
  1365.         if ( *entry == cmw->complex_menu.label )
  1366.         return(NULL);    /* cannot select the label. */
  1367.         else
  1368.         return(*entry);
  1369.         }
  1370.     }
  1371.  
  1372.     return(NULL);
  1373. }
  1374.  
  1375. #endif /*]*/
  1376.